~singpolyma/biboumi

biboumi/src/database/database.cpp -rw-r--r-- 12.1 KiB
12223354Stephen Paul Weber Fix caps hash 5 months ago
                                                                                
74c73799 Florent Le Coz
4bd7b698 louiz’
88ae2599 Florent Le Coz
992fa938 louiz’
3047bd41 louiz’
9500bfd4 louiz’
88ae2599 Florent Le Coz
bfcf2945 louiz’
0168b96b louiz’
bfcf2945 louiz’
0168b96b louiz’
2c717d34 louiz’
0168b96b louiz’
84034ed3 louiz’
577984fa louiz’
655151d8 louiz’
84034ed3 louiz’
bfcf2945 louiz’
88ae2599 Florent Le Coz
50cadf3d louiz’
88ae2599 Florent Le Coz
4d55a120 louiz’
0168b96b louiz’
a557718b louiz’
4f7ad3f9 Jonas Wielicki
0168b96b louiz’
577984fa louiz’
0168b96b louiz’
88ae2599 Florent Le Coz
61de6b1d louiz’
50cadf3d louiz’
6776b827 louiz’
4bd7b698 louiz’
b71ca15a louiz’
50cadf3d louiz’
0168b96b louiz’
50cadf3d louiz’
4bd7b698 louiz’
50cadf3d louiz’
6776b827 louiz’
50cadf3d louiz’
88ae2599 Florent Le Coz
4bd7b698 louiz’
b71ca15a louiz’
50cadf3d louiz’
0168b96b louiz’
50cadf3d louiz’
4bd7b698 louiz’
50cadf3d louiz’
88ae2599 Florent Le Coz
577984fa louiz’
4bd7b698 louiz’
577984fa louiz’
5af0a804 louiz’
577984fa louiz’
4bd7b698 louiz’
577984fa louiz’
50cadf3d louiz’
421c960d Florent Le Coz
4bd7b698 louiz’
b71ca15a louiz’
0168b96b louiz’
50cadf3d louiz’
4bd7b698 louiz’
50cadf3d louiz’
421c960d Florent Le Coz
50cadf3d louiz’
421c960d Florent Le Coz
992fa938 louiz’
50cadf3d louiz’
421c960d Florent Le Coz
50cadf3d louiz’
6776b827 louiz’
50cadf3d louiz’
6776b827 louiz’
50cadf3d louiz’
6776b827 louiz’
50cadf3d louiz’
421c960d Florent Le Coz
50cadf3d louiz’
61de6b1d louiz’
50cadf3d louiz’
8ec823be louiz’
50cadf3d louiz’
8ec823be louiz’
7f2127a7 louiz’
50cadf3d louiz’
61de6b1d louiz’
50cadf3d louiz’
8ec823be louiz’
4bd7b698 louiz’
7f2127a7 louiz’
8ec823be louiz’
b0168fd4 louiz’
d1626c92 louiz’
4bd7b698 louiz’
b71ca15a louiz’
3047bd41 louiz’
61de6b1d louiz’
3047bd41 louiz’
61de6b1d louiz’
3047bd41 louiz’
a90f196a louiz’
0280343c louiz’
a90f196a louiz’
4a2a280d louiz’
a90f196a louiz’
0280343c louiz’
50cadf3d louiz’
fd7c3652 louiz’
1236b8a0 louiz’
fd7c3652 louiz’
1236b8a0 louiz’
50cadf3d louiz’
b0168fd4 louiz’
50cadf3d louiz’
0168b96b louiz’
b0168fd4 louiz’
fd7c3652 louiz’
05ba076a louiz’
fd7c3652 louiz’
05ba076a louiz’
d1626c92 louiz’
0280343c louiz’
4bd7b698 louiz’
0280343c louiz’
61de6b1d louiz’
0280343c louiz’
61de6b1d louiz’
0280343c louiz’
84034ed3 louiz’
4bd7b698 louiz’
84034ed3 louiz’
0168b96b louiz’
84034ed3 louiz’
4bd7b698 louiz’
84034ed3 louiz’
0168b96b louiz’
84034ed3 louiz’
4bd7b698 louiz’
84034ed3 louiz’
0168b96b louiz’
84034ed3 louiz’
4bd7b698 louiz’
84034ed3 louiz’
0168b96b louiz’
84034ed3 louiz’
88ae2599 Florent Le Coz
e1c7a651 Jonas Wielicki
88ae2599 Florent Le Coz
74c73799 Florent Le Coz
8ec823be louiz’
9500bfd4 louiz’
8ec823be louiz’
5af0a804 louiz’
84034ed3 louiz’
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
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
#include "biboumi.h"
#ifdef USE_DATABASE

#include <database/select_query.hpp>
#include <database/save.hpp>
#include <database/database.hpp>
#include <utils/get_first_non_empty.hpp>
#include <utils/time.hpp>
#include <utils/uuid.hpp>

#include <config/config.hpp>
#include <database/sqlite3_engine.hpp>
#include <database/postgresql_engine.hpp>

#include <database/engine.hpp>
#include <database/index.hpp>

#include <memory>

std::unique_ptr<DatabaseEngine> Database::db;
Database::MucLogLineTable Database::muc_log_lines("muclogline_");
Database::GlobalOptionsTable Database::global_options("globaloptions_");
Database::IrcServerOptionsTable Database::irc_server_options("ircserveroptions_");
Database::IrcChannelOptionsTable Database::irc_channel_options("ircchanneloptions_");
Database::RosterTable Database::roster("roster");
Database::AfterConnectionCommandsTable Database::after_connection_commands("after_connection_commands_");
std::map<Database::CacheKey, Database::EncodingIn::real_type> Database::encoding_in_cache{};

Database::GlobalPersistent::GlobalPersistent():
    Column<bool>{Config::get_bool("persistent_by_default", false)}
{}

void Database::open(const std::string& filename)
{
  // Try to open the specified database.
  // Close and replace the previous database pointer if it succeeded. If it did
  // not, just leave things untouched
  std::unique_ptr<DatabaseEngine> new_db;
  static const auto psql_prefix = "postgresql://"s;
  static const auto psql_prefix2 = "postgres://"s;
  if ((filename.substr(0, psql_prefix.size()) == psql_prefix) ||
      (filename.substr(0, psql_prefix2.size()) == psql_prefix2))
    new_db = PostgresqlEngine::open(filename);
  else
    new_db = Sqlite3Engine::open(filename);
  if (!new_db)
    return;
  Database::db = std::move(new_db);
  Database::muc_log_lines.create(*Database::db);
  Database::muc_log_lines.upgrade(*Database::db);
  Database::global_options.create(*Database::db);
  Database::global_options.upgrade(*Database::db);
  Database::irc_server_options.create(*Database::db);
  Database::irc_server_options.upgrade(*Database::db);
  Database::irc_channel_options.create(*Database::db);
  Database::irc_channel_options.upgrade(*Database::db);
  Database::roster.create(*Database::db);
  Database::roster.upgrade(*Database::db);
  Database::after_connection_commands.create(*Database::db);
  Database::after_connection_commands.upgrade(*Database::db);
  create_index<Database::Owner, Database::IrcChanName, Database::IrcServerName>(*Database::db, "archive_index", Database::muc_log_lines.get_name());
}


Database::GlobalOptions Database::get_global_options(const std::string& owner)
{
  auto request = select(Database::global_options);
  request.where() << Owner{} << "=" << owner;

  auto result = request.execute(*Database::db);
  if (result.size() == 1)
    return result.front();
  Database::GlobalOptions options{Database::global_options.get_name()};
  options.col<Owner>() = owner;
  return options;
}

Database::IrcServerOptions Database::get_irc_server_options(const std::string& owner, const std::string& server)
{
  auto request = select(Database::irc_server_options);
  request.where() << Owner{} << "=" << owner << " and " << Server{} << "=" << server;

  auto result = request.execute(*Database::db);
  if (result.size() == 1)
    return result.front();
  Database::IrcServerOptions options{Database::irc_server_options.get_name()};
  options.col<Owner>() = owner;
  options.col<Server>() = server;
  return options;
}

Database::AfterConnectionCommands Database::get_after_connection_commands(const IrcServerOptions& server_options)
{
  const auto id = server_options.col<Id>();
  if (id == Id::unset_value)
    return {};
  auto request = select(Database::after_connection_commands);
  request.where() << ForeignKey{} << "=" << id;
  return request.execute(*Database::db);
}

void Database::set_after_connection_commands(const Database::IrcServerOptions& server_options, Database::AfterConnectionCommands& commands)
{
  const auto id = server_options.col<Id>();
  if (id == Id::unset_value)
    return ;

  Transaction transaction;
  auto query = Database::after_connection_commands.del();
  query.where() << ForeignKey{} << "=" << id;
  query.execute(*Database::db);

  for (auto& command: commands)
    {
      command.col<ForeignKey>() = server_options.col<Id>();
      save(command, *Database::db);
    }
}

Database::IrcChannelOptions Database::get_irc_channel_options(const std::string& owner, const std::string& server, const std::string& channel)
{
  auto request = select(Database::irc_channel_options);
  request.where() << Owner{} << "=" << owner <<\
          " and " << Server{} << "=" << server <<\
          " and " << Channel{} << "=" << channel;
  auto result = request.execute(*Database::db);
  if (result.size() == 1)
    return result.front();
  Database::IrcChannelOptions options{Database::irc_channel_options.get_name()};
  options.col<Owner>() = owner;
  options.col<Server>() = server;
  options.col<Channel>() = channel;
  return options;
}

Database::IrcChannelOptions Database::get_irc_channel_options_with_server_default(const std::string& owner, const std::string& server,
                                                                                  const std::string& channel)
{
  auto coptions = Database::get_irc_channel_options(owner, server, channel);
  auto soptions = Database::get_irc_server_options(owner, server);

  coptions.col<EncodingIn>() = get_first_non_empty(coptions.col<EncodingIn>(),
                                                   soptions.col<EncodingIn>());
  coptions.col<EncodingOut>() = get_first_non_empty(coptions.col<EncodingOut>(),
                                                    soptions.col<EncodingOut>());

  coptions.col<MaxHistoryLength>() = get_first_non_empty(coptions.col<MaxHistoryLength>(),
                                                         soptions.col<MaxHistoryLength>());

  return coptions;
}

Database::IrcChannelOptions Database::get_irc_channel_options_with_server_and_global_default(const std::string& owner, const std::string& server, const std::string& channel)
{
  auto coptions = Database::get_irc_channel_options(owner, server, channel);
  auto soptions = Database::get_irc_server_options(owner, server);
  auto goptions = Database::get_global_options(owner);

  coptions.col<EncodingIn>() = get_first_non_empty(coptions.col<EncodingIn>(),
                                                   soptions.col<EncodingIn>());

  coptions.col<EncodingOut>() = get_first_non_empty(coptions.col<EncodingOut>(),
                                                    soptions.col<EncodingOut>());

  return coptions;
}

std::string Database::store_muc_message(const std::string& owner, const std::string& chan_name,
                                        const std::string& server_name, Database::time_point date,
                                        const std::string& body, const std::string& nick)
{
  auto line = Database::muc_log_lines.row();

  auto uuid = Database::gen_uuid();

  line.col<Uuid>() = uuid;
  line.col<Owner>() = owner;
  line.col<IrcChanName>() = chan_name;
  line.col<IrcServerName>() = server_name;
  line.col<Date>() = std::chrono::duration_cast<std::chrono::seconds>(date.time_since_epoch()).count();
  line.col<Body>() = body;
  line.col<Nick>() = nick;

  save(line, *Database::db);

  return uuid;
}

std::tuple<bool, std::vector<Database::MucLogLine>> Database::get_muc_logs(const std::string& owner, const std::string& chan_name, const std::string& server,
                                                   std::size_t limit, const std::string& start, const std::string& end, const Id::real_type reference_record_id, Database::Paging paging)
{
  auto request = select(Database::muc_log_lines);
  request.where() << Database::Owner{} << "=" << owner << \
          " and " << Database::IrcChanName{} << "=" << chan_name << \
          " and " << Database::IrcServerName{} << "=" << server;

  if (!start.empty())
    {
      const auto start_time = utils::parse_datetime(start);
      if (start_time != -1)
        request << " and " << Database::Date{} << ">=" << start_time;
    }
  if (!end.empty())
    {
      const auto end_time = utils::parse_datetime(end);
      if (end_time != -1)
        request << " and " << Database::Date{} << "<=" << end_time;
    }
  if (reference_record_id != Id::unset_value)
    {
      request << " and " << Id{};
      if (paging == Database::Paging::first)
        request << ">";
      else
        request << "<";
      request << reference_record_id;
    }

  if (paging == Database::Paging::first)
    request.order_by() << Id{} << " ASC ";
  else
    request.order_by() << Id{} << " DESC ";

  // Just a simple trick: to know whether we got the totality of the
  // possible results matching this query (except for the limit), we just
  // ask one more element. If we get that additional element, this means
  // we don’t have everything. And then we just discard it. If we don’t
  // have more, this means we have everything.
  request.limit() << limit + 1;

  auto result = request.execute(*Database::db);
  bool complete = true;

  if (result.size() == limit + 1)
    {
      complete = false;
      result.erase(std::prev(result.end()));
    }

  if (paging == Database::Paging::first)
    return {complete, result};
  else
    return {complete, {result.crbegin(), result.crend()}};
}

Database::MucLogLine Database::get_muc_log(const std::string& owner, const std::string& chan_name, const std::string& server,
                                           const std::string& uuid, const std::string& start, const std::string& end)
{
  auto request = select(Database::muc_log_lines);
  request.where() << Database::Owner{} << "=" << owner << \
          " and " << Database::IrcChanName{} << "=" << chan_name << \
          " and " << Database::IrcServerName{} << "=" << server << \
          " and " << Database::Uuid{} << "=" << uuid;

  if (!start.empty())
    {
      const auto start_time = utils::parse_datetime(start);
      if (start_time != -1)
        request << " and " << Database::Date{} << ">=" << start_time;
    }
  if (!end.empty())
    {
      const auto end_time = utils::parse_datetime(end);
      if (end_time != -1)
        request << " and " << Database::Date{} << "<=" << end_time;
    }

  auto result = request.execute(*Database::db);

  if (result.empty())
    throw Database::RecordNotFound{};
  return result.front();
}

void Database::add_roster_item(const std::string& local, const std::string& remote)
{
  auto roster_item = Database::roster.row();

  roster_item.col<Database::LocalJid>() = local;
  roster_item.col<Database::RemoteJid>() = remote;

  save(roster_item, *Database::db);
}

void Database::delete_roster_item(const std::string& local, const std::string& remote)
{
  Query query("DELETE FROM "s + Database::roster.get_name());
  query << " WHERE " << Database::RemoteJid{} << "=" << remote << \
           " AND " << Database::LocalJid{} << "=" << local;

//  query.execute(*Database::db);
}

bool Database::has_roster_item(const std::string& local, const std::string& remote)
{
  auto query = select(Database::roster);
  query.where() << Database::LocalJid{} << "=" << local << \
        " and " << Database::RemoteJid{} << "=" << remote;

  auto res = query.execute(*Database::db);

  return !res.empty();
}

std::vector<Database::RosterItem> Database::get_contact_list(const std::string& local)
{
  auto query = select(Database::roster);
  query.where() << Database::LocalJid{} << "=" << local;

  return query.execute(*Database::db);
}

std::vector<Database::RosterItem> Database::get_full_roster()
{
  auto query = select(Database::roster);

  return query.execute(*Database::db);
}

void Database::close()
{
  Database::db = nullptr;
}

std::string Database::gen_uuid()
{
  return utils::gen_uuid();
}

Transaction::Transaction()
{
  const auto result = Database::raw_exec("BEGIN");
  if (std::get<bool>(result) == false)
    log_error("Failed to create SQL transaction: ", std::get<std::string>(result));
  else
    this->success = true;
}

Transaction::~Transaction()
{
  if (this->success)
    {
      const auto result = Database::raw_exec("END");
      if (std::get<bool>(result) == false)
        log_error("Failed to end SQL transaction: ", std::get<std::string>(result));
    }
}
#endif