NoSQL решение за запазване на графики в мащаб

Има два основни типа контейнери за съхраняване на графики:

1. бази данни с истински графики: напр. Neo4J, agamemnon, GraphDB и AllegroGraph; те не само съхраняват графика, но също така разбират, че графиката е, така че например можете да направите запитване към тези бази данни, например колко възли има между най-краткия път от възел X и възел Y?

2. статични графични контейнери: адаптираната към MySQL FlockDB на Twitter е най-известният пример тук. Тези DB могат да съхраняват и извличат графики добре; но за да поискате самата графика, първо трябва да извлечете графиката от DB, след което да използвате библиотека (напр. отличната Networkx на Python), за да направите заявка за самата графика.

Графичният контейнер, базиран на redis, който обсъждам по-долу, е във втората категория, въпреки че очевидно redis също е подходящ за контейнери в първата категория, както се вижда от redis-graph, забележително малък пакет на python за внедряване на графична база данни в redis.

redis ще работи прекрасно тук.

Redis е мощно, издръжливо хранилище на данни, подходящо за производствена употреба, но също така е достатъчно лесно за използване за анализ от командния ред.

Redis е различен от другите бази данни по това, че има множество типове структура на данни; този, който бих препоръчал тук, е типът данни хеш. Използването на тази структура от данни на redis ви позволява много точно да имитирате „списък от речници“, конвенционална схема за съхраняване на графики, в която всеки елемент в списъка е речник на ръбове, свързани с възела, от който произхождат тези ръбове.

Първо трябва да инсталирате redis и клиента на python. Блогът на DeGizmo има отличен „актуален“ урок, който включва ръководство стъпка по стъпка за инсталиране и на двете.

След като redis и неговият python клиент са инсталирани, стартирайте redis сървър, което правите по следния начин:

• cd към директорията, в която сте инсталирали redis (/usr/local/bin на 'nix, ако сте инсталирали чрез make install); следващия

• въведете redis-server в подканата на обвивката, след което въведете

сега трябва да видите лог файла на сървъра в прозореца на вашата обвивка

>>> import numpy as NP
>>> import networkx as NX

>>> # start a redis client & connect to the server:
>>> from redis import StrictRedis as redis
>>> r1 = redis(db=1, host="localhost", port=6379)

Във фрагмента по-долу съм съхранил графика с четири възела; всеки ред по-долу извиква hmset на клиента redis и съхранява един възел и ръбовете, свързани с този възел ("0" => без ръб, "1" => ръб). (На практика, разбира се, бихте абстрахирали тези повтарящи се извиквания във функция; тук показвам всяко извикване, защото вероятно е по-лесно за разбиране по този начин.)

>>> r1.hmset("n1", {"n1": 0, "n2": 1, "n3": 1, "n4": 1})
      True

>>> r1.hmset("n2", {"n1": 1, "n2": 0, "n3": 0, "n4": 1})
      True

>>> r1.hmset("n3", {"n1": 1, "n2": 0, "n3": 0, "n4": 1})
      True

>>> r1.hmset("n4", {"n1": 0, "n2": 1, "n3": 1, "n4": 1})
      True

>>> # retrieve the edges for a given node:
>>> r1.hgetall("n2")
      {'n1': '1', 'n2': '0', 'n3': '0', 'n4': '1'}

Сега, когато графиката е запазена, извлечете я от redis DB като NetworkX графика.

Има много начини да направите това, по-долу го направете в две *стъпки*:

1. извлечете данните от базата данни redis в матрица на съседство, реализирана като 2D NumPy масив; тогава

2. конвертирайте това директно в графика на NetworkX с помощта на вградена функция на NetworkX:

редуцирани до код, тези две стъпки са:

>>> AM = NP.array([map(int, r1.hgetall(node).values()) for node in r1.keys("*")])
>>> # now convert this adjacency matrix back to a networkx graph:
>>> G = NX.from_numpy_matrix(am)

>>> # verify that G in fact holds the original graph:
>>> type(G)
      <class 'networkx.classes.graph.Graph'>
>>> G.nodes()
      [0, 1, 2, 3]
>>> G.edges()
      [(0, 1), (0, 2), (0, 3), (1, 3), (2, 3), (3, 3)]

Когато приключите redis сесия, можете да изключите сървъра от клиента по следния начин:

>>> r1.shutdown()

redis записва на диск точно преди да се изключи, така че това е добър начин да се гарантира, че всички записи са запазени.

И така, къде е redis DB? Той се съхранява в местоположението по подразбиране с името на файла по подразбиране, което е dump.rdb във вашата начална директория.

За да промените това, редактирайте файла redis.conf (включен в разпространението на източника на redis); отидете на реда, започващ с:

# The filename where to dump the DB
dbfilename dump.rdb

променете dump.rdb с каквото желаете, но оставете разширението .rdb на място.

След това, за да промените пътя на файла, намерете този ред в redis.conf:

# Note that you must specify a directory here, not a file name

Редът под това е местоположението на директорията за базата данни redis. Редактирайте го така, че да рецитира местоположението, което искате. Запазете ревизиите си и преименувайте този файл, но запазете разширението .conf. Можете да съхранявате този конфигурационен файл навсякъде, където пожелаете, просто предоставете пълния път и име на този персонализиран конфигурационен файл на същия ред, когато стартирате redis сървър:

Така че следващия път, когато стартирате redis сървър, трябва да го направите така (от подканата на обвивката:

$> cd /usr/local/bin    # or the directory in which you installed redis 

$> redis-server /path/to/redis.conf

И накрая, Индексът на пакетите на Python изброява пакет специално за внедряване на графична база данни в redis. Пакетът се нарича redis-graph и не съм го използвал.

Има реализация на NetworkX, поддържана от SQLlite3, наречена Cloudlight. https://www.assembla.com/spaces/cloudlight/wiki/Tutorial

Ще ми е интересно да видя най-добрия начин за използване на твърдия диск. В миналото съм правил множество графики и съм ги записвал като .dot файлове. След това смесих някои от тях в паметта по някакъв начин. Все пак не е най-доброто решение.

from random import random
import networkx as nx

def make_graph():
    G=nx.DiGraph()
    N=10
    #make a random graph
    for i in range(N):
        for j in range(i):
            if 4*random()<1:
                G.add_edge(i,j)

    nx.write_dot(G,"savedgraph.dot")
    return G

try:
    G=nx.read_dot("savedgraph.dot")
except:
    G=make_graph() #This will fail if you don't use the same seed but have created the graph in the past. You could use the Singleton design pattern here.
print G.adj