GlobalsDB — универсальная NoSQL база данных. Часть 2

Часть 1.

Моделируем 4 вида NoSQL-баз с помощью GlobalsDB

Перед тем как мы начнём моделировать различные виды NoSQL-баз, давайте взглянем на глобалы чуть более детатально и определим некоторые термины, которые будем использовать позднее.

При сохранении данных в элементе глобала используются 3 компонента:

• Имя глобала
• Индексы (ноль, один или несколько). Они могут быть текстовыми или численными.
• Значение (которое, собственно, и хранится в элементе глобала). Оно м.б. текстовым или численным

Эти три компонента часто записываются как N-арная реляционная переменная следующим образом:

globalName[subscript1, subscript2, ..subscriptN] = value 

Это комбинация имени, индексов и значения известна как элемент глобала (Global Node) и является единицей хранения. Глобал состоит из множества его элементов, а база данных состоит из множества глобалов.

Важным свойством глобалов является то, что одиночный глобал может содержать узлы с различным числом индексов, например:

myGlobal["a"] = 123 myGlobal["b", "c1"] = "foo" myGlobal["b", "c2"] = "foo2" myGlobal["d", "e1", "f1"] = "bar1" myGlobal["d", "e1", "f2"] = "bar2" myGlobal["d", "e2", "f1"] = "bar1" myGlobal["d", "e2", "f2"] = "bar2" myGlobal["d", "e2", "f3"] = "bar3" 

В конечном счёте одиночный глобал представляет собой разреженное иерархическое дерево элементов. Например, глобал приведённый выше описывает следующее иерархическое дерево:

Вы можете создать сколько угодно глобалов с разными именами. Другими словами, база данных в GlobalsDB состоит из одного или нескольких глобалов, каждый из которых представляет иерахию элементов.

В такой базе нет явных связей между различными глобалами, но могут быть скрытые связи, которые определяются и обслуживаются на уровне приложения.

Также в рамках БД нет явной схемы или структуры данных, которые хранятся в глобалах. Способ хранения данных в глобалах определяется на уровне приложения.

Элементы в глобалах создаются командой set. Точный синтаксис этой команды зависит от используемого API.

Так, для Node.JS API мы можем двумя способами создавать элементы один и тот же элемент глобала.

Асинхронно:

var globalNode = {   global:"myGlobal",   subscripts: ["b","c3"],   data: "Rob" }; db.set(globalNode, function(error,results) { // etc }); 

или синхронно:

var globalNode = {   global:"myGlobal",   subscripts: ["b","c3"],   data: "Rob" }; db.set(globalNode); 

Одним из интересных свойств GlobalsDB является то, можно широко использовать синхронное программирование без вреда для производительности, что упрощает работу с ней и позволяет использовать ОО-синтаксис в полном объёме внутри JavaScript.

Это возможно из-за уникальной производительности GlobalsDB: она работает в связке c NodeJS как подлинкованный процесс в оперативной памяти (в отличие от многих других NoSQL-баз, которые работают через различные сетевые сокеты), и в сочетании с глубокой оптимизацией, которая, как уже было озвучено, даёт производительность как у баз в памяти в RAM. Подобного сочетания свойств нет у самых популярных NoSQL-баз.

Примечание переводчика: Однако если нужна именно сетевая NoSQL-база, то сделать её на том же Node.JS + GlobalsDB нетрудно — достаточно написать API на основе JSON, например.

Вызов вышеописанной команды приведёт к вставке элемента в нашу иерархию и дерево приобретёт новый вид:

Давайте теперь, помня основные свойства глобалов, посмотрим как мы можем их использовать для представления типовых структур данных, для хранения которых используются NoSQL-базы.

1) Хранилище Ключ/Значение

Реализация хранилища типа Ключ/Хначение на глобалах элементарна. Мы создаём его используя следующую структуру:

keyValueStore[key] = value 

Например:

telephone["211-555-9012"] = "James, George" telephone["617-555-1414"] = "Tweed, Rob" 

В виде иерархического дерева эта структура выглядит так:

Всё, хранилище типа Ключ/Значение реализовано. Однако с помощью глобалов мы можем пойти дальше и сохранять несколько аттрибутов для одного ключа. Например, так:

Telephone[phoneNumber, "name"] == value Telephone[phoneNumber, "address"] == value 

Пример с конкретными данными:

telephone["211-555-9012", "name"] = "James, George" telephone["211-555-9012", "address"] = "5308, 12th Avenue, Brooklyn" telephone["617-555-1414", "name"] = "Tweed, Rob" telephone["617-555-1414", "address"] = "112 Beacon Street, Boston" 

Мы создали иерархическое дерево, которое выглядит так:

Вот код на Node.JS API для создания первой записи в этом улучшенном хранилище типа ключ/значение:

var gnode = {   global: "telephone",   subscripts: ["617-555-1414", "name"],   data: "Tweed, Rob" }; db.set(gnode); 

NoSQL-базы обычно не представляют автоматических способов для индексирования данных. Однако в БД на глобалах, если вам нужен доступ к данным по альтернативному ключу, то достаточно создать второй глобал, в котором в качестве ключа может выступать любое поле.

Например, если нам нужен доступ к данным по полю name, мы должны создать индексный глобал и обновлять его вместе с глобалом telephone. Проектирование и добавление индексов полностью лежит на вас, как разработчике, но это очень просто.

Для поддержки индекса по полю name каждый раз при добавлении записей в глобал telephone мы будем создавать элемент в глобале nameIndex:

nameIndex[name, phoneNumber] = "" 

nameIndex["James, George", "211-555-9012"] = "" nameIndex["Tweed, Rob", "617-555-1414"] = "" 

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

На диаграмме показаны глобал с телефонными данными и индексный глобал. Пунктирной линией показаны неявные отношения между индексом и основным глобалом:

Индексный глобал позволяет нам получить доступ к данным по имени, в то время как основной глобал предоставляет доступ по телефонному номеру.

Очень важным и мощным свойством глобалов является хранение элементов в отсортированном виде (см. диаграмму ниже), все операции для этого происходят автоматически при сохранении.

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

Если нам нужно создать телефонный справочник из наших данных, то мы можем последовательно обойти элементы глобала nameIndex и получить адреса из глобала telephone с помощью метода get().

Метод-итератор для обхода — это функция order. Вот пример на Node.js API:

gnode = {   global: "nameIndex",   subscripts:["James, George"] }; var nextName = db.order(gnode).result; 

Этот код должен вернуть индекс элемента, следующего за элементом с индексом «James, George» в данном глобале. То есть:

nextName = "Tweed, Rob" 

GlobalsDB чрезвычайно хорошо оптимизирована для обхода индексов этим способом, так что если вы хорошо спроектируете свои индексы, то поиск данных в глобале будет исключительно быстрым.

Принципиально мы рассмотрели все пути использования глобалов в качестве простых хранилищ типа Ключ/Значение. Кстати, наше хранилище может быть перепроектировано для использования всего лишь одного глобала и для данных, и для индексов. Для этого нужно добавить ещё один индекс первого уровня, например так:

telephone["data", phoneNumber, "address"] = address telephone["data", phoneNumber, "name"] = name telephone["nameIndex", name, phoneNumber] = "" 

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

Другие типы хранилищ Ключ/Значение

Если мы взглянем на такое Ключ/Значение-хранилище как Redis, то увидим, что оно предлагает несколько других способов хранения данных. Каждый из этих способов может быть очень просто реализован на глобалах.

Списки

Списки в Redis являются связанными. Можно поместить значения в список и извлечь значения из списка, получить подсписок и т.п.

Модель подобного списка на глобалах очень проста. Например, можно использовать следующую структуру:

list[listName, "firstNode"] = nodeNo list[listName, "lastNode"] = nodeNo list[listName, "node", nodeNo, "value"] = value list[listName, "node", nodeNo, "nextNode"] = nextNodeNo list[listName, "node", nodeNo, "previousNode"] = prevNodeNo 

Например, связанный список под названием myList, содержащий последовательность значений:

• Rob
• George
• John

может быть представлен как:

list["myList", "firstNode"] = 5 list["myList", "lastNode"] = 2 list["myList", "nodeCounter"] = 5 list["myList", "node", 2, "previousNode"] = 4 list["myList", "node", 2, "value"] = "John" list["myList", "node", 4, "nextNode"] = 2 list["myList", "node", 4, "previousNode"] = 5 list["myList", "node", 4, "value"] = "George" list["myList", "node", 5, "nextNode"] = 4 list["myList", "node", 5, "value"] = "Rob" 

или графически:

На этом рисунке видна разреженная природа глобалов. Номер элемента списка — это последовательное целое число. Элемент 5 на данный момент первый элемент в списке, поэтому он имеет аттрибут nextNode в котором хранится следующий элемент списка и не имеет аттрибута previousNode для предыдущего элемента списка.

Средний элемент списка под номером 4 имеет аттрибуты для хранения номерров предыдущего и последующего элементов.

Каждая операция, которая изменяет связанный список (вставляет, извлекает, удаляет, укорачивает и т.п.), должна изменить несколько элементов внутри этого списка, например:

• сбросить указатель на первый или последний узел
• добавить или удалить значение элемента
• установить корректные значения следующего и предыдущего элементов, чтобы вставить или удалить элемент из списка

Например, чтобы вставить новое имя «Chris» в начало списка мы должны изменить глобал, где хранится список так:

list["myList", "firstNode"] = 6 list["myList", "lastNode"] = 2 list["myList", "nodeCounter"] = 6 list["myList", "node", 2, "previousNode"] = 4 list["myList", "node", 2, "value"] = "John" list["myList", "node", 4, "nextNode"] = 2 list["myList", "node", 4, "previousNode"] = 5 list["myList", "node", 4, "value"] = "George" list["myList", "node", 5, "nextNode"] = 4 list["myList", "node", 5, "previousNode"] = 6 list["myList", "node", 5, "value"] = "Rob" list["myList", "node", 6, "nextNode"] = 5 list["myList", "node", 6, "value"] = "Chris" 

Графическая схема изменений (то что изменилось подсвечено):

Для обхода списка мы должны начать с первого элемента и рекурсивно переходить от элемента к элементу по номеру в поле nextNode, до тех пор пока у очередного элемента мы не найдём данного поля:

Чтобы найти число элементов в списке мы можем выполнить его обход, или, для максимальной производительности, хранить это число в отдельном элементе глобала и обновлять при изменении списка:

List["myList", "count"] = noOfNodes 

Понятно, что мы должны написать эти операции как методы, чтобы легко и корректно манипулировать элементами в списке, но это весьма простая задача.

Множества (Sets)

Множества в Redis это неупорядоченный набор строк. Мы можем легко смоделировать их на глобалах:

theSet[setName, elementValue] = "" 

Вы можете заметить, что это в точности совпадает со способом задания индексов, рассмотренным ранее. А вот так можно добавить элемент в множество:

Set: theSet["mySet", "Rob"] = "" 

Удаление элемента из множества:

Kill: theSet["mySet", "Rob"] 

Для определения вхождения элемента в множество мы можем использовать команду data. Она вернёт 1, если элемент входит в множество, и 0, если нет.

Data: theSet["mySet", "Rob"] → 1 Data: theSet["mySet", "Robxxx"] → 0 

В Node.js API мы можем использовать метод data

gnode = {   global: "theset",   subscripts: ["mySet", "Rob"] }; var exists = db.data(gnode).defined; 

В этом примере переменная exists получит значение 1.

Мы можем использовать упорядоченность элементов глобала, чтобы отобразить члены множества в алфавитной последовательности.

При использовании глобалов нет никакой значимой разницы при моделировании Redis-множеств set и zset.

Хэши.

Вы наверное уже заметили, что набор хэшей может быть реализован точно также как множества. В своей сущности глобалы и есть хранимые таблицы хэшей.

Hash[hashName, value] = "" 

2) Табличные (или колоночные) хранилища

Табличные или колоночные NoSQL-базы такие как BigTable, Cassandra и Amazon SimpleDB позволяют сохранять данные в разреженных таблицах, подразумевая что каждая строка может содержать значения в некоторых, но необязательно во всех, столбцах.

SimpleDB в дополнение позволяет каждой ячейке в столбце содержать более одного значения.

Опять таки это означает, что такие хранилища могут быть смоделированы на глобалах. Следующая структура предоставляет базовые возможности такого хранилища:

columnStore[columnName, rowId] = value 

Пример с конкретными данными:

user["dateOfBirth", 3] = "1987-01-23" user["email", 1] = "rob@foo.com" user["email", 2] = "george@foo.com" user["name", 1] = "Rob" user["name", 2] = "George" user["name", 3] = "John" user["state", 1] = "MA" user["state", 2] = "NY" user["telephone", 2] = "211-555-4121" 

В виде диаграммы:

Опять нам пригодилась разреженная природа глобалов. Вышеописанный глобал представляет следующую таблицу:

	name	telephone	email	dateOfBirth	state
1	Rob		rob@foo.com		MA
2	George	211-555-4121	george@foo.com		NY
3	John			1987-01-23

Конечно, можно ещё добавить индексы к этой модели, например, по строке и по значению ячейки, которые нужно поддерживать одновременно с основным глобалом для хранения столбцов, например так:

userIndex["byRow", rowId, columnName] = "" userIndex["byValue", value, columnName, rowId] = "" 

3) Документо-ориентированное хранилище

Документо-ориентированные NoSQL БД такие как CouchDB и MongoDB хранят множество пар ключ/значение и вложенные множества множеств различных аттрибутов.

Обычно используются JSON или JSON-подобные структуры для представления «документов» хранящихся в этих БД. GlobalsDB автоматически отображает JSON-документы или объекты в глобалы.

Для примера рассмотрим JSON-документ:

{key:"value"} 

Он может быть смоделирован на глобалах как:

Document["key"] = "value" 

В GlobalsDB мы мы можем создать этот документ так:

var json = {   node: {     global: "Document",     subscripts: []   },   object: {     key: "value"   } }; db.update(json, 'object'); 

И получить его из БД так:

var json = db.retrieve({global: 'Document'},"object"); console.log("Document = " + JSON.stringify(json.object)); 

Давайте возьмём более сложный документ:

{this:{looks:{very:"cool"}}} 

Его можно представить следующим элементом глобала:

Document["this", "looks", "very"] = "cool" 

А создать его можно так:

var json = {   node: {     global: "Document",     subscripts: []   },   object: {     this: {       looks: {         very: "cool"       }     }   } }; db.update(json, "object"); 

А что насчёт массива?

["this","is","cool"] 

Он может быть представлен так:

document[1] = "this" document[2] = "is" document[3] = "cool" 

GlobalsDB для создания и получения отображения данных на глобалы использует объекты, а не массивы. Поэтому для сохранения массива мы напишем так:

var json = {   node: {     global: "Document",     subscripts: []   },   object: {     1: "this",     2: "is",     3: "cool"   } }; db.update(json, "object"); 

Для получения массива из БД:

var json = db.retrieve({global: "Document"}, "object"); console.log("Document = " + JSON.stringify(json.object)); Document = {"1":"this", "2":"is", "3":"cool"} 

Приведём более сложный JSON-документ:

{   "age": "26",   "contact": {     "address": {       "city": "Boston",       "street": "112 Beacon Street"     },     "cell": "617-555-1761",     "email": "rob@foo.com",     "telephone": "617-555-1212"   },   "knows": {     "1": "George",     "2": "John",     "3": "Chris"   },   "medications": {     "1": {       "dose": "5mg",       "drug": "Zolmitripan"     },     "2": {       "dose": "500mg",       "drug": "Paracetemol"     }   },   "name": "Rob",   "sex": "Male" } 

Он будет отображён на глобалы так:

person["age"] = 26 person["contact", "address", "city"] = "Boston" person["contact", "address", "street"] = "112 Beacon Street" person["contact", "cell"] = "617-555-1761" person["contact", "eMail"] = "rob@foo.com" person["contact", "telephone"] = "617-555-1212" person["knows", 1] = "George" person["knows", 2] = "John" person["knows", 3] = "Chris" person["medications", 1, "drug"] = "Zolmitripan" person["medications", 1, "dose"] = "5mg" person["medications", 2, "drug"] = "Paracetamol" person["medications", 2, "dose"] = "500mg" person["name"] = "Rob" person["sex"] = "Male" 

Или графически:

Мы можем создать этот документ в GlobalsDB так:

var json = {   node: {     global: "person",     subscripts: []   },   object: {     name: "Rob",     age: 26,     knows: {       1: "George",       2: "John",       3: "Chris"     },     medications: {       1: {         drug: "Zolmitripan",         dose: "5mg"       },       2: {         drug: "Paracetemol",         dose: "500mg"       }     },     contact: {       email: "rob@foo.com",       address: {         street: "112 Beacon Street",         city: "Boston"       },       telephone: "617-555-1212",       cell: "617-555-1761"     },     sex: "Male"   } }; db.update(json, "object"); 

И получить так:

var json = db.retrieve({global: "person"}, "object").object; 

4) Графовые базы данных

NoSQL-базы такие как Neo4j используются для представления сложных сетей взаимосвязей в терминах узлов и связей между ними (т.н. рёбер) с помощью пар ключ/значение связывающих узлы и рёбра.

Классическое использование графовой БД это представление социального графа. Давайте рассмотрим следующий пример:

В этом примере стрелками показано какие пользователи знают (know) о других. С помощью глобалов он может быть представлен так:

person[personId, "knows", personId] = "" person[personId, "knows", personId, key) = value person[personId, "name"] = name 

Время состояния «knows» («знает») может быть вычислено из временного штампа, который сохраняется при первичном создании связи, например так:

person[1, "knows", 2] = "" person[1, "knows", 2, "disclosure"] = "public" person[1, "knows", 2, "timestamp"] = "2008-08-16T12:23:01Z" person[1, "knows", 7] = "" person[1, "name"] = "Rob" person[2, "name"] = "John" person[7, "knows", 2] = "" person[7, "knows", 2, "disclosure"] = "public" person[7, "knows", 2, "timestamp"] = "2009-12-16T10:06:44Z" person[7, "name"] = "George" 

или графически (красные точечные пунктирные линии показывают отношения «know» между пользователями в этой модели):

Если говорить об общем случае графовой БД, модель будет представлять узлы и рёбра (edge) между ними. Примерно так:

node[nodeType, nodeId] = "" node[nodeType, nodeId, attribute] = attributeValue edge[edgeType, fromNodeId, toNodeId] = "" edge[edgeType, fromNodeId, toNodeId, attribute] = attributeValue edgeReverse[edgeType, toNodeId, fromNodeId] = "" 

Таким образом, разреженная природа и гибкость глобалов позволяет очень органично и просто определять сложные графовые БД.

5) Модели других баз данных

Моделирование на глобалах не ограничивается только NoSQL-моделями данных. Они также могут быть использованы для моделирования:

• XML DOM/Native XML-баз данных. GlobalsDB отлично подходит для работы с сохраняемыми XML DOM файлами. XML-документ, по существу, это граф, который представляет узлы различных типов и отношения между ними (например firstChild, lastChild, nextSibling, parent и т.п.). В сущности это позволяет GlobalsDB выступать в роли Native XML-базы данных. Модуль для Node.js ewdDOM — одна легковесных реализаций такой БД.
• Реляционные таблицы. Caché моделирует реляционные таблицы на глобалах, таким образом что можно использовать стандартные SQL-запросы. Т.е. GlobalsDB можно рассматривать как основу для NoSQL-движка, а в Caché добавлены возможности NOSQL (т.е Not-Only SQL — не только SQL) базы данных.
• Объектная БД. Caché моделирует на глобалах объекты, а также предоставляет прямое отображение между объектами и реляционными таблицами. Наверное, теперь вы понимаете как это реализовано.

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

Это похоже как будто у вас есть Redis, CouchDB, SimpleDB, Neo4j и Native XML БД запущенные в одной базе данных и в одно и тоже время!

Если вы заинтересованы в NoSQL-базе работающей с Node.JS (а также .NET, Java), вам необходимо взглянуть в сторону GlobalsDB. Это воистину Универсальная NoSQL база данных!

Заключение

Конечно, способов использования глобалов значительно больше, чем приведено в данной статье. Однако, надеюсь, этот обзор продемострировал, что они удобный гибкий инструмент для абстракции и способны весьма просто моделировать различные NoSQL-базы.

Секретный соус — конечно, реализация. Если она сделана корректно, применены мудрые проектные решения, то достигнутая производительность поразительна.

Благодарность
Эта статья представляет собой адаптацию статьи Роба Твида и Джорджа Джеймса «Универсальная NoSql база данных на основе проверенной и протестированной технологии» (2010).