mirror of
https://github.com/matrix-construct/construct
synced 2024-08-19 08:04:43 +02:00
279 lines
5.6 KiB
C++
279 lines
5.6 KiB
C++
// The Construct
|
|
//
|
|
// Copyright (C) The Construct Developers, Authors & Contributors
|
|
// Copyright (C) 2016-2020 Jason Volk <jason@zemos.net>
|
|
//
|
|
// Permission to use, copy, modify, and/or distribute this software for any
|
|
// purpose with or without fee is hereby granted, provided that the above
|
|
// copyright notice and this permission notice is present in all copies. The
|
|
// full license for this software is available in the LICENSE file.
|
|
|
|
namespace ircd::m::dbs
|
|
{
|
|
static bool event_state__cmp_lt(const string_view &, const string_view &);
|
|
}
|
|
|
|
decltype(ircd::m::dbs::event_state)
|
|
ircd::m::dbs::event_state;
|
|
|
|
decltype(ircd::m::dbs::desc::event_state__block__size)
|
|
ircd::m::dbs::desc::event_state__block__size
|
|
{
|
|
{ "name", "ircd.m.dbs._event_state.block.size" },
|
|
{ "default", 512L },
|
|
};
|
|
|
|
decltype(ircd::m::dbs::desc::event_state__meta_block__size)
|
|
ircd::m::dbs::desc::event_state__meta_block__size
|
|
{
|
|
{ "name", "ircd.m.dbs._event_state.meta_block.size" },
|
|
{ "default", long(2_KiB) },
|
|
};
|
|
|
|
decltype(ircd::m::dbs::desc::event_state__cache__size)
|
|
ircd::m::dbs::desc::event_state__cache__size
|
|
{
|
|
{
|
|
{ "name", "ircd.m.dbs._event_state.cache.size" },
|
|
{ "default", long(16_MiB) },
|
|
}, []
|
|
{
|
|
const size_t &value{event_state__cache__size};
|
|
db::capacity(db::cache(dbs::event_state), value);
|
|
}
|
|
};
|
|
|
|
decltype(ircd::m::dbs::desc::event_state__cache_comp__size)
|
|
ircd::m::dbs::desc::event_state__cache_comp__size
|
|
{
|
|
{
|
|
{ "name", "ircd.m.dbs._event_state.cache_comp.size" },
|
|
{ "default", long(0_MiB) },
|
|
}, []
|
|
{
|
|
const size_t &value{event_state__cache_comp__size};
|
|
db::capacity(db::cache_compressed(dbs::event_state), value);
|
|
}
|
|
};
|
|
|
|
const ircd::db::comparator
|
|
ircd::m::dbs::desc::event_state__cmp
|
|
{
|
|
"_event_state",
|
|
event_state__cmp_lt,
|
|
std::equal_to<string_view>{},
|
|
};
|
|
|
|
const ircd::db::descriptor
|
|
ircd::m::dbs::desc::event_state
|
|
{
|
|
// name
|
|
"_event_state",
|
|
|
|
// explanation
|
|
R"(Index of states of events.
|
|
|
|
state_key, type, room_id, depth, event_idx => --
|
|
|
|
The state transitions of events are indexed by this column,
|
|
based on the state_key property.
|
|
|
|
)",
|
|
|
|
// typing (key, value)
|
|
{
|
|
typeid(string_view), typeid(string_view)
|
|
},
|
|
|
|
// options
|
|
{},
|
|
|
|
// comparator
|
|
event_state__cmp,
|
|
|
|
// prefix transform
|
|
{},
|
|
|
|
// drop column
|
|
false,
|
|
|
|
// cache size
|
|
bool(cache_enable)? -1 : 0, //uses conf item
|
|
|
|
// cache size for compressed assets
|
|
bool(cache_comp_enable)? -1 : 0,
|
|
|
|
// bloom filter bits
|
|
0,
|
|
|
|
// expect queries hit
|
|
false,
|
|
|
|
// block size
|
|
size_t(event_state__block__size),
|
|
|
|
// meta_block size
|
|
size_t(event_state__meta_block__size),
|
|
|
|
// compression
|
|
"kLZ4Compression;kSnappyCompression"s,
|
|
|
|
// compactor
|
|
{},
|
|
|
|
// compaction priority algorithm
|
|
"kOldestSmallestSeqFirst"s,
|
|
};
|
|
|
|
//
|
|
// indexer
|
|
//
|
|
|
|
void
|
|
ircd::m::dbs::_index_event_state(db::txn &txn,
|
|
const event &event,
|
|
const write_opts &opts)
|
|
{
|
|
assert(opts.appendix.test(appendix::EVENT_STATE));
|
|
assert(json::get<"type"_>(event));
|
|
assert(opts.event_idx);
|
|
|
|
if(!defined(json::get<"state_key"_>(event)))
|
|
return;
|
|
|
|
thread_local char buf[EVENT_STATE_KEY_MAX_SIZE];
|
|
db::txn::append
|
|
{
|
|
txn, dbs::event_state,
|
|
{
|
|
opts.op, event_state_key(buf, event_state_tuple
|
|
{
|
|
at<"state_key"_>(event),
|
|
at<"type"_>(event),
|
|
at<"room_id"_>(event),
|
|
at<"depth"_>(event),
|
|
opts.event_idx,
|
|
})
|
|
}
|
|
};
|
|
}
|
|
|
|
//
|
|
// cmp
|
|
//
|
|
|
|
bool
|
|
ircd::m::dbs::event_state__cmp_lt(const string_view &a,
|
|
const string_view &b)
|
|
{
|
|
const event_state_tuple key[2]
|
|
{
|
|
event_state_key(a),
|
|
event_state_key(b),
|
|
};
|
|
|
|
const auto &[state_key_a, type_a, room_id_a, depth_a, event_idx_a]
|
|
{
|
|
key[0]
|
|
};
|
|
|
|
const auto &[state_key_b, type_b, room_id_b, depth_b, event_idx_b]
|
|
{
|
|
key[1]
|
|
};
|
|
|
|
if(state_key_a != state_key_b)
|
|
return state_key_a < state_key_b;
|
|
|
|
if(type_a != type_b)
|
|
return type_a < type_b;
|
|
|
|
if(room_id_a != room_id_b)
|
|
return room_id_a < room_id_b;
|
|
|
|
if(depth_a != depth_b)
|
|
return depth_a > depth_b;
|
|
|
|
if(event_idx_a != event_idx_b)
|
|
return event_idx_a > event_idx_b;
|
|
|
|
return false;
|
|
}
|
|
|
|
//
|
|
// key
|
|
//
|
|
|
|
ircd::m::dbs::event_state_tuple
|
|
ircd::m::dbs::event_state_key(const string_view &amalgam)
|
|
{
|
|
assert(!startswith(amalgam, '\0'));
|
|
const auto &[state_key, r0]
|
|
{
|
|
split(amalgam, "\0"_sv)
|
|
};
|
|
|
|
const auto &[type, r1]
|
|
{
|
|
split(r0, "\0"_sv)
|
|
};
|
|
|
|
const auto &[room_id, r2]
|
|
{
|
|
split(r1, "\0"_sv)
|
|
};
|
|
|
|
assert(!room_id || m::valid(m::id::ROOM, room_id));
|
|
return event_state_tuple
|
|
{
|
|
state_key,
|
|
type,
|
|
room_id,
|
|
r2.size() >= 8?
|
|
int64_t(byte_view<int64_t>(r2.substr(0, 8))):
|
|
-1L,
|
|
r2.size() >= 16?
|
|
event::idx(byte_view<uint64_t>(r2.substr(8))):
|
|
0UL,
|
|
};
|
|
}
|
|
|
|
ircd::string_view
|
|
ircd::m::dbs::event_state_key(const mutable_buffer &out_,
|
|
const event_state_tuple &tuple)
|
|
{
|
|
assert(size(out_) >= EVENT_STATE_KEY_MAX_SIZE);
|
|
|
|
const auto &[state_key, type, room_id, depth, event_idx]
|
|
{
|
|
tuple
|
|
};
|
|
|
|
if(!state_key)
|
|
return {};
|
|
|
|
mutable_buffer out{out_};
|
|
consume(out, copy(out, state_key));
|
|
if(!type)
|
|
return {data(out_), data(out)};
|
|
|
|
consume(out, copy(out, "\0"_sv));
|
|
consume(out, copy(out, type));
|
|
if(!room_id)
|
|
return {data(out_), data(out)};
|
|
|
|
assert(m::valid(m::id::ROOM, room_id));
|
|
consume(out, copy(out, "\0"_sv));
|
|
consume(out, copy(out, room_id));
|
|
if(depth < 0)
|
|
return {data(out_), data(out)};
|
|
|
|
consume(out, copy(out, "\0"_sv));
|
|
consume(out, copy(out, byte_view<string_view>(depth)));
|
|
if(!event_idx)
|
|
return {data(out_), data(out)};
|
|
|
|
consume(out, copy(out, byte_view<string_view>(event_idx)));
|
|
return {data(out_), data(out)};
|
|
}
|