MirrorHub/construct
0
0
Fork 0
mirror of https://github.com/matrix-construct/construct synced 2024-11-17 15:30:52 +01:00
Code Issues Releases Wiki Activity

ircd::db: Cleanup comparator related.

Browse source
This commit is contained in:
Jason Volk 2017-09-22 18:48:35 -07:00
parent 2a17d2b939
commit b29224aa3a
2 changed files with 66 additions and 60 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

50
include/ircd/db/comparator.h
View file

@ -27,13 +27,57 @@ namespace ircd::db
{
struct comparator;
struct cmp_string_view extern const cmp_string_view;
struct cmp_int64_t extern const cmp_int64_t;
struct cmp_int64_t;
struct cmp_string_view;
}
struct ircd::db::comparator
{
std::string name;
string_view name;
std::function<bool (const string_view &, const string_view &)> less;
std::function<bool (const string_view &, const string_view &)> equal;
};
struct ircd::db::cmp_string_view
:db::comparator
{
static bool less(const string_view &a, const string_view &b)
{
return a < b;
}
static bool equal(const string_view &a, const string_view &b)
{
return a == b;
}
cmp_string_view()
:db::comparator{"string_view", less, equal}
{}
};
struct ircd::db::cmp_int64_t
:db::comparator
{
static bool less(const string_view &sa, const string_view &sb)
{
assert(sa.size() == sizeof(int64_t));
assert(sb.size() == sizeof(int64_t));
const byte_view<int64_t> a{sa};
const byte_view<int64_t> b{sb};
return a < b;
}
static bool equal(const string_view &sa, const string_view &sb)
{
assert(sa.size() == sizeof(int64_t));
assert(sb.size() == sizeof(int64_t));
const byte_view<int64_t> a{sa};
const byte_view<int64_t> b{sb};
return a == b;
}
cmp_int64_t()
:db::comparator{"int64_t", less, equal}
{}
};

76
ircd/db.cc
View file

@ -710,7 +710,7 @@ ircd::db::database::comparator::Name()
const
{
assert(!user.name.empty());
return user.name.c_str();
return user.name.data();
}
bool
@ -719,9 +719,7 @@ ircd::db::database::comparator::Equal(const Slice &a,
const
{
assert(bool(user.equal));
const string_view sa{slice(a)};
const string_view sb{slice(b)};
return user.equal(sa, sb);
return user.equal(slice(a), slice(b));
}
int
@ -730,11 +728,13 @@ ircd::db::database::comparator::Compare(const Slice &a,
const
{
assert(bool(user.less));
const string_view sa{slice(a)};
const string_view sb{slice(b)};
return user.less(sa, sb)? -1:
user.less(sb, sa)? 1:
0;
const auto sa{slice(a)};
const auto sb{slice(b)};
return user.less(sa, sb)? -1: // less[Y], equal[?], greater[?]
user.equal && user.equal(sa, sb)? 0: // less[N], equal[Y], greater[?]
user.equal? 1: // less[N], equal[N], greater[Y]
user.less(sb, sa)? 1: // less[N], equal[?], greater[Y]
0; // less[N], equal[Y], greater[N]
}
void
@ -751,52 +751,6 @@ const
const string_view limit{_limit.data(), _limit.size()};
}
struct ircd::db::cmp_string_view
:db::comparator
{
cmp_string_view()
:db::comparator
{
"string_view"
,[](const string_view &a, const string_view &b)
{
return a < b;
}
,[](const string_view &a, const string_view &b)
{
return a == b;
}
}{}
}
const ircd::db::cmp_string_view;
struct ircd::db::cmp_int64_t
:db::comparator
{
cmp_int64_t()
:db::comparator
{
"int64_t"
,[](const string_view &sa, const string_view &sb)
{
assert(sa.size() == sizeof(int64_t));
assert(sb.size() == sizeof(int64_t));
const auto &a(*reinterpret_cast<const int64_t *>(sa.data()));
const auto &b(*reinterpret_cast<const int64_t *>(sb.data()));
return a < b;
}
,[](const string_view &sa, const string_view &sb)
{
assert(sa.size() == sizeof(int64_t));
assert(sb.size() == sizeof(int64_t));
const auto &a(*reinterpret_cast<const int64_t *>(sa.data()));
const auto &b(*reinterpret_cast<const int64_t *>(sb.data()));
return a == b;
}
}{}
}
const ircd::db::cmp_int64_t;
///////////////////////////////////////////////////////////////////////////////
//
// database::prefix_transform
@ -919,9 +873,9 @@ ircd::db::database::column::column(database *const &d,
if(!this->descriptor.cmp.less)
{
if(key_type == typeid(string_view))
this->cmp.user = cmp_string_view;
this->cmp.user = cmp_string_view{};
else if(key_type == typeid(int64_t))
this->cmp.user = cmp_int64_t;
this->cmp.user = cmp_int64_t{};
else
throw error("column '%s' key type[%s] requires user supplied comparator",
this->name,
@ -943,6 +897,14 @@ ircd::db::database::column::column(database *const &d,
//log.debug("'%s': Creating new column '%s'", d->name, this->name);
//throw_on_error(d->d->CreateColumnFamily(this->options, this->name, &this->handle));
log.debug("schema '%s' declares column [%s => %s] cmp[%s] prefix[%s]: %s",
db::name(*d),
demangle(key_type.name()),
demangle(mapped_type.name()),
this->cmp.Name(),
this->options.prefix_extractor? this->prefix.Name() : "none",
this->descriptor.name);
}
ircd::db::database::column::~column()