Выражение нескольких столбцов в berkeley db в python?

Вы должны выбрать один «столбец» в качестве ключа (должен быть уникальным; я полагаю, что в вашем случае это будет «имя пользователя») - единственный способ, которым когда-либо будет выполняться поиск. Другие столбцы можно сделать единственным строковым значением этого ключа любым удобным для вас способом, от травления до простого соединения с символом, который гарантированно никогда не будет встречаться ни в одном из столбцов, например `\0' для многих видов «читаемые текстовые строки».

Если вам нужна возможность поиска по разным ключам, вам потребуются другие, дополнительные и отдельные базы данных bsddb, настроенные как «индексы» в вашей основной таблице — это большая работа, и по этому вопросу есть много литературы. (В качестве альтернативы вы переходите к технологии более высокой абстракции, такой как sqlite, которая аккуратно обрабатывает индексацию от вашего имени ;-).

tl,dr: Чтобы выразить несколько столбцов в упорядоченном хранилище значений ключей, таком как berkley db, вам необходимо изучить композицию ключей. Посмотрите другие мои ответы о bsddb, чтобы узнать больше.

Есть несколько способов сделать это, используя упорядоченное хранилище ключей/значений.

Самое простое решение — сохранять документы как значения json с правильным ключом.

Теперь вы, вероятно, захотите построить индекс по этим столбцам для извлечения документов без необходимости перебирать всю хэш-карту, чтобы найти правильный объект. Для этого вы можете использовать вторичную БД, которая автоматически создаст индекс для ты. Или вы можете создать индекс самостоятельно.

Если вы не хотите иметь дело с упаковкой ключей (и это хорошая идея для запуска), вы можете воспользоваться из DB.set_bt_compare, что позволит вам использовать cpickle, json или msgpack для ключей и значений, сохраняя при этом порядок, который имеет смысл для создания индексов и выполнения запросов. Это более медленный метод, но в нем используется шаблон композиции клавиш.

Чтобы в полной мере воспользоваться тем, что такое упорядоченный ключ, вы можете использовать Cursor.set_range(key) для установки позиции базы данных в начале запроса.

Другой шаблон, называемый шаблон EAV, хранит кортежи, которые следуют схеме (entity, attribute, value), а затем вы строите различные индексы, используя перестановку этого кортежа. Я изучил этот шаблон, изучая datomic.

Для менее ресурсоемкой базы данных вы пойдете по пути «статической типизации» и сохраните как можно больше общей информации в таблице «метаданные» и разделите документы (которые на самом деле являются таблицами СУБД) в их собственную хэш-карту.

Для начала здесь приведен пример базы данных с использованием bsddb (но вы можете создать ее с использованием другого упорядоченного хранилища ключей/значений, такого как wiredtiger или leveldb), который реализует шаблон EAV. В этой реализации я заменяю EAV на IKV, что означает уникальный идентификатор, ключ, значение. Общий результат заключается в том, что у вас есть полностью индексированная база данных документов без схемы. Я думаю, что это хороший компромисс между эффективностью и простотой использования.

import struct

from json import dumps
from json import loads

from bsddb3.db import DB
from bsddb3.db import DBEnv
from bsddb3.db import DB_BTREE
from bsddb3.db import DB_CREATE
from bsddb3.db import DB_INIT_MPOOL
from bsddb3.db import DB_LOG_AUTO_REMOVE


def pack(*values):
    def __pack(value):
        if type(value) is int:
            return '1' + struct.pack('>q', value)
        elif type(value) is str:
            return '2' + struct.pack('>q', len(value)) + value
        else:
            data = dumps(value, encoding='utf-8')
            return '3' + struct.pack('>q', len(data)) + data
    return ''.join(map(__pack, values))


def unpack(packed):
    kind = packed[0]
    if kind == '1':
        value = struct.unpack('>q', packed[1:9])[0]
        packed = packed[9:]
    elif kind == '2':
        size = struct.unpack('>q', packed[1:9])[0]
        value = packed[9:9+size]
        packed = packed[size+9:]
    else:
        size = struct.unpack('>q', packed[1:9])[0]
        value = loads(packed[9:9+size])
        packed = packed[size+9:]
    if packed:
        values = unpack(packed)
        values.insert(0, value)
    else:
        values = [value]
    return values


class TupleSpace(object):
    """Generic database"""

    def __init__(self, path):
        self.env = DBEnv()
        self.env.set_cache_max(10, 0)
        self.env.set_cachesize(5, 0)
        flags = (
            DB_CREATE |
            DB_INIT_MPOOL
        )
        self.env.log_set_config(DB_LOG_AUTO_REMOVE, True)
        self.env.set_lg_max(1024 ** 3)
        self.env.open(
            path,
            flags,
            0
        )

        # create vertices and edges k/v stores
        def new_store(name):
            flags = DB_CREATE
            elements = DB(self.env)
            elements.open(
                name,
                None,
                DB_BTREE,
                flags,
                0,
            )
            return elements
        self.tuples = new_store('tuples')
        self.index = new_store('index')
        self.txn = None

    def get(self, uid):
        cursor = self.tuples.cursor()

        def __get():
            record = cursor.set_range(pack(uid, ''))
            if not record:
                return
            key, value = record
            while True:
                other, key = unpack(key)
                if other == uid:
                    value = unpack(value)[0]
                    yield key, value
                    record = cursor.next()
                    if record:
                        key, value = record
                        continue
                    else:
                        break
                else:
                    break

        tuples = dict(__get())
        cursor.close()
        return tuples

    def add(self, uid, **properties):
        for key, value in properties.items():
            self.tuples.put(pack(uid, key), pack(value))
            self.index.put(pack(key, value, uid), '')

    def delete(self, uid):
        # delete item from main table and index
        cursor = self.tuples.cursor()
        index = self.index.cursor()
        record = cursor.set_range(pack(uid, ''))
        if record:
            key, value = record
        else:
            cursor.close()
            raise Exception('not found')
        while True:
            other, key = unpack(key)
            if other == uid:
                # remove tuple from main index
                cursor.delete()

                # remove it from index
                value = unpack(value)[0]
                index.set(pack(key, value, uid))
                index.delete()

                # continue
                record = cursor.next()
                if record:
                    key, value = record
                    continue
                else:
                    break
            else:
                break
        cursor.close()

    def update(self, uid, **properties):
        self.delete(uid)
        self.add(uid, **properties)

    def close(self):
        self.index.close()
        self.tuples.close()
        self.env.close()

    def debug(self):
        for key, value in self.tuples.items():
            uid, key = unpack(key)
            value = unpack(value)[0]
            print(uid, key, value)

    def query(self, key, value=''):
        """return `(key, value, uid)` tuples that where
        `key` and `value` are expressed in the arguments"""
        cursor = self.index.cursor()
        match = (key, value) if value else (key,)

        record = cursor.set_range(pack(key, value))
        if not record:
            cursor.close()
            return

        while True:
            key, _ = record
            other = unpack(key)
            ok = reduce(
                lambda previous, x: (cmp(*x) == 0) and previous,
                zip(match, other),
                True
            )
            if ok:
                yield other
                record = cursor.next()
                if not record:
                    break
            else:
                break
        cursor.close()


db = TupleSpace('tmp')
# you can use a tuple to store a counter
db.add(0, counter=0)

# And then have a procedure doing the required work
# to alaways have a fresh uid
def make_uid():
    counter = db.get(0)
    counter['counter'] += 1
    return counter['counter']

amirouche = make_uid()
db.add(amirouche, username="amirouche", age=30)
print(db.get(amirouche))