La mise en œuvre d'un Modèle de Référentiel en Python?

Principalement par curiosité, je suis à la recherche d'un Python cadre ou un exemple pour le Modèle de Référentiel de découplage de la persistance de la logique de la logique de domaine.

Le nom de "Modèle de Référentiel" s'affiche dans le post "Démêler Domaine et la Persistance de la Logique avec la Conservatrice" (Ruby), l'idée vient d'une section de "Domain-Driven Design" livre et Martin Fowler. Le modèle de classe ne contient pas de persistance de la logique, mais plutôt l'application déclare référentiel sous-classes dont les instances agissent comme des collections en mémoire des instances de modèle. Chaque référentiel persiste le modèle de différentes façons, par exemple SQL (divers schéma conventions), à Riak ou d'autres noSQL et à la mémoire (pour la mise en cache). Cadre de conventions de dire référentiel sous-classes nécessitent généralement un minimum de code: il suffit de déclarer "WidgetRepository" sous-classe de SQLRepository serait de fournir une collection qui persiste le modèle Widget à la table DB nommé "widgets" et faire correspondre les colonnes d'attributs des widgets.

Différences par rapport aux autres modèles:

Modèle d'Enregistrement Active: par exemple, l'ORM de Django. L'application définit simplement le modèle de classe avec le domaine de la logique et de certaines métadonnées pour la persistance. L'ORM ajoute la persistance de la logique de la classe du modèle. Cette mélanges de domaine et de la persistance dans une classe (indésirables selon le poste).

Grâce à @marcin je vois que lors de l'Enregistrement Actif prend en charge divers backends et .enregistrer(à l'aide d'="other_database") de la fonction, que donne le multi-backend avantage du Modèle de Référentiel.

Donc, en un sens, le Modèle de Référentiel est juste comme Active Record, avec la persistance de la logique déplacé à une catégorie distincte.

Motif de Mapper des données: par exemple, SQLAlchemy Classique de Mappages. L'application définit des classes supplémentaires pour table de base de données(s), et de mapper des données(s) de modèle à table(s). Ainsi, le modèle de l'instance peuvent être mappées à des tables dans de multiples façons, par exemple, à l'appui de l'héritage des schémas. Ne pense pas que SQLAlchemy fournit les cartographes à la non-SQL de stockage.

Quelle est ta recherche? Je viens de facilement googlé un certain nombre de solutions de rechange.
Googler pour python "repository pattern" ne sont pas tous les implémentations. Qu'est-ce exactement avez-vous recherché?
google.co.uk/search?q=django+orm+backend
il n'y a aucune questions sur StackExchange - ils principalement sur NHibernate
Autant que je sache, l'ORM de Django génère le SQL (une représentation uniquement) pour chaque modèle. Modèle de référentiel otoh, que fournit la collection de classes pour chaque backend (par exemple, SQL, MongoDB, de mémoire), sous-classé pour fournir de multiples façons de conserver le modèle.

OriginalL'auteur Graham | 2012-03-14

  1. 1

    Vous pourriez avoir un bon coup d'oeil à James Dennis DictShield projet

    "DictShield est une base de données indépendant du système de modélisation. Il fournit un moyen de modèle, de valider et de remodeler les données facilement. Le tout sans avoir besoin tout particulier de la base de données."

    DictShield fournit des aides pour la modélisation, la validation, concernant les modèles. Modèle de référentiel permettrait de fournir de la collection de comme des classes pour les différents backends.

    OriginalL'auteur Jordan Dimov

  2. 10

    Hors de ma tête:

    Je définir deux exemples de domaines, User et Animal, un stockage de base de la classe Store et deux de Stockage spécialisé classes UserStore et AnimalStore. Utilisation du gestionnaire de contexte ferme la connexion db (pour des raisons de simplicité j'utilise sqlite dans cet exemple):

    import sqlite3
def get_connection():
return sqlite3.connect('test.sqlite')
class StoreException(Exception):
def __init__(self, message, *errors):
Exception.__init__(self, message)
self.errors = errors
# domains
class User():
def __init__(self, name):
self.name = name
class Animal():
def __init__(self, name):
self.name = name
# base store class
class Store():
def __init__(self):
try:
self.conn = get_connection()
except Exception as e:
raise StoreException(*e.args, **e.kwargs)
self._complete = False
def __enter__(self):
return self
def __exit__(self, type_, value, traceback):
# can test for type and handle different situations
self.close()
def complete(self):
self._complete = True
def close(self):
if self.conn:
try:
if self._complete:
self.conn.commit()
else:
self.conn.rollback()
except Exception as e:
raise StoreException(*e.args)
finally:
try:
self.conn.close()
except Exception as e:
raise StoreException(*e.args)
# store for User obects
class UserStore(Store):
def add_user(self, user):
try:
c = self.conn.cursor()
# this needs an appropriate table
c.execute('INSERT INTO user (name) VALUES(?)', (user.name,))
except Exception as e:
raise StoreException('error storing user')
# store for Animal obects
class AnimalStore(Store):
def add_animal(self, animal):
try:
c = self.conn.cursor()
# this needs an appropriate table
c.execute('INSERT INTO animal (name) VALUES(?)', (animal.name,))
except Exception as e:
raise StoreException('error storing animal')
# do something
try:
with UserStore() as user_store:
user_store.add_user(User('John'))
user_store.complete()
with AnimalStore() as animal_store:
animal_store.add_animal(Animal('Dog'))
animal_store.add_animal(Animal('Pig'))
animal_store.add_animal(Animal('Cat'))
animal_store.add_animal(Animal('Wolf'))
animal_store.complete()
except StoreException as e:
# exception handling here
print(e)
    Oui, cela ne mettre en œuvre le Modèle de Référentiel. Dans une bibliothèque fournissant, j'espère pour chaque backend de stockage pour fournir une stratégie par défaut pour la carte de modèles de stockage, donc, pas écrit à la main SQL est nécessaire.
    href="http://www.sqlalchemy.org/" >SQLAlchemy peut-être ce que vous voulez, mais ce n'est pas léger, voir SQLAlchemy session.
    Vous pouvez certainement utiliser cette méthode pour obtenir les référentiels de travail. Pour la base de données agnostiques suffit d'utiliser SQLAlchemy pour mettre en œuvre les mécanismes internes.
    J'aime l'utilisation du gestionnaire de contexte ici (tellement que je vais voler de mes propres mise en œuvre! 🙂 ).
    La pièce qui est le gestionnaire de contexte?

    OriginalL'auteur laurasia