MirrorHub/construct
0
0
Fork 0
mirror of https://github.com/matrix-construct/construct synced 2024-11-29 18:22:50 +01:00
Code Issues Releases Wiki Activity

ircd::db: Update README; remove old cruft.

Browse source
This commit is contained in:
Jason Volk 2017-12-03 13:34:42 -08:00
parent 6027a68105
commit 94b5bc75d3
2 changed files with 3 additions and 177 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

21
include/ircd/db/README.md
View file

@ -5,10 +5,9 @@ The database is an object store built from the primitives of `cell`, `column`, a
#### Columns #### Columns
While a simple key-value store could naively store a JSON document as a textual While a simple key-value store could naively store a JSON document as a textual
value, we provide additional structure schematized before opening a database: value, we provide additional structure schematized before opening a database:
Every member of a JSON object is a `column` in this database. To address members Every member of a JSON object is a `column` in this database. There is no
within nested objects, we specify a `column` with a "foo.bar.baz" path syntax. This specific support for recursion at this time, though that could be addressed
puts all columns at the same level in our code, even though they may represent by adding additional columns for the nested values.
deeply nested values.
#### Rows #### Rows
Since `columns` are technically independent key-value stores (they have their own Since `columns` are technically independent key-value stores (they have their own
@ -21,20 +20,6 @@ takes the form of a single JSON object and any member lookup happens on a user's
A `cell` is a single value in a `column` indexed by a key that should be able to form A `cell` is a single value in a `column` indexed by a key that should be able to form
a `row` between columns. Consider the following near-json expression: a `row` between columns. Consider the following near-json expression:
users["root"] = {"password", "foobar"};
In the users database, we find the `column` "password" and the `row` for "root" and
set that `cell` to "foobar"
Consider these expressions for objects at some depth:
users["root"] = {"password.plaintext", "foobar"};
users["root"] = {"password", {"plaintext, "foobar"}};
The column is always found as "password.plaintext". We find it (and can iterate its members
if it were an object) by string-manipulating these full paths which all sit in a single map
and are always open, even if the cell is empty for some row.
### Important notes ### Important notes
!!! !!!

159
include/ircd/db/value.h
View file

@ -1,159 +0,0 @@
/*
* Copyright (C) 2016 Charybdis Development Team
* Copyright (C) 2016 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.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
* IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
*/
#pragma once
#define HAVE_IRCD_DB_VALUE_H
namespace ircd::db
{
template<database *const &d, class T = string_view> struct value;
template<database *const &d> struct value<d, void>;
template<database *const &d> struct value<d, string_view>;
template<database *const &d, class T> struct arithmetic_value;
}
template<ircd::db::database *const &d,
class T>
struct ircd::db::value
{
};
template<ircd::db::database *const &d>
struct ircd::db::value<d, void>
:cell
{
using cell::cell;
value(const string_view &name,
const string_view &index)
:cell{*d, name, index}
{}
};
template<ircd::db::database *const &d>
struct ircd::db::value<d, ircd::string_view>
:value<d, void>
{
operator string_view() const
{
return string_view{static_cast<const cell &>(*this)};
}
operator string_view()
{
return string_view{static_cast<cell &>(*this)};
}
using cell::cell;
value(const string_view &col,
const string_view &row)
:value<d, void>{col, row}
{}
value &operator=(const string_view &val)
{
static_cast<cell &>(*this) = val;
return *this;
}
friend std::ostream &operator<<(std::ostream &s, const value<d, string_view> &v)
{
s << string_view{v};
return s;
}
};
template<ircd::db::database *const &d,
class T>
struct ircd::db::arithmetic_value
:value<d, void>
{
bool compare_exchange(T &expected, const T &desired)
{
const auto ep(reinterpret_cast<const char *>(&expected));
const auto dp(reinterpret_cast<const char *>(&desired));
string_view s{ep, expected? sizeof(T) : 0};
const auto ret(cell::compare_exchange(s, string_view{dp, sizeof(T)}));
expected = !s.empty()? *reinterpret_cast<const T *>(s.data()) : 0;
return ret;
}
T exchange(const T &desired)
{
const auto dp(reinterpret_cast<const char *>(&desired));
const auto ret(cell::exchange(string_view{dp, desired? sizeof(T) : 0}));
return !ret.empty()? *reinterpret_cast<const T *>(ret.data()) : 0;
}
operator T() const
{
const auto val(this->val());
return !val.empty()? *reinterpret_cast<const T *>(val.data()) : 0;
}
operator T()
{
const auto val(this->val());
return !val.empty()? *reinterpret_cast<const T *>(val.data()) : 0;
}
using cell::cell;
arithmetic_value(const string_view &col,
const string_view &row)
:value<d, void>{col, row}
{}
arithmetic_value &operator=(const T &val)
{
cell &cell(*this);
const auto ptr(reinterpret_cast<const char *>(&val));
cell = string_view{ptr, val? sizeof(T) : 0};
return *this;
}
friend std::ostream &operator<<(std::ostream &s, const arithmetic_value &v)
{
s << T(v);
return s;
}
};
#define IRCD_ARITHMETIC_VALUE(_type_) \
template<database *const &d> \
struct value<d, _type_> \
:arithmetic_value<d, _type_> \
{ \
using arithmetic_value<d, _type_>::arithmetic_value; \
}
namespace ircd::db
{
IRCD_ARITHMETIC_VALUE(uint64_t);
IRCD_ARITHMETIC_VALUE(int64_t);
IRCD_ARITHMETIC_VALUE(uint32_t);
IRCD_ARITHMETIC_VALUE(int32_t);
IRCD_ARITHMETIC_VALUE(uint16_t);
IRCD_ARITHMETIC_VALUE(int16_t);
}