MongoDB ORM dla Pythona? [Zamknięte]

Próbuję migrować z sqlalchemy (SQlite) do korzystania z mongodb. Chciałbym wertifikować schemat. Patrzę na mongokit, ale chcę czegoś, co jest podobne do mapperów, aby oszczędzało z własności obiektu, a nie dyktu.

Chciałbym mappera, aby móc używać istniejących obiektów bez ich modyfikowania.

Inną opcją jest MongoEngine . ORM dla MongoEngine jest bardzo podobny do ORM używanego przez Django.

Przykład (z samouczka):

class Post(Document):
    title = StringField(max_length=120, required=True)
    author = ReferenceField(User)

class TextPost(Post):
    content = StringField()

class ImagePost(Post):
    image_path = StringField()

class LinkPost(Post):
    link_url = StringField()

Nie będąc zadowolony ani z MongoKit, ani z MongoEngine, zdecydowałem się napisać własny interfejs zorientowany obiektowo dla Pythona.

Wszystkie zapytania przekazałem bezpośrednio do pymongo, więc składnia zapytań jest taka sama. Przeważnie jest to tylko otoka obiektów wokół wyników, z kilkoma innymi pomocnikami, takimi jak pule połączeń bazy danych, obsługa DBRef i inne wygodne metody ułatwiające życie.

Nazywa się Minimongo i jest dostępny na github. Miłego hakowania!

Przykład:

from minimongo import Model, MongoCollection 

class MyObject(Model): 
    model = MongoCollection(database='test', collection='my_collection')

m = MyObject()
m.x = 1
m.field = 'value'
m.other = {'list': True}
m.save()

x = MyObject({'x': 1, 'y': 2}).save()

objs = MyObject.find({'x': 1})
for o in objs: 
    print o

Chcesz MongoKit . Jest to jedna warstwa abstrakcji wyższa niż PyMongo . Nie jestem pewien, czy używasz Django, ale jest też integracja django-mongokit .

Przykład z tego wpisu na blogu . Zwróć uwagę, że instancje Computer mogą następnie odwoływać się do marki / modelu bezpośrednio po zdefiniowaniu struktury (np. Atari.make, c64.model, ...). Nie ma potrzeby używania słowników:

import datetime 
from mongokit import Document

class Computer(Document):

    structure = { 
      'make': unicode, 
      'model': unicode, 
      'purchase_date': datetime.datetime, 
      'cpu_ghz': float, 
    }

    validators = { 
      'cpu_ghz': lambda x: x > 0, 
      'make': lambda x: x.strip(), 
    }

    default_values = { 
      'purchase_date': datetime.datetime.utcnow, 
    }

    use_dot_notation = True

    indexes = [ 
      {'fields': ['make']}, 
    ]

Wiem, że jestem naprawdę spóźniony z tym pytaniem, ale jestem autorem Ming http://merciless.sourceforge.net , opartego na SQLAlchemy walidacji MongoDB i silnika ORM. To jest to, czego używamy w SourceForge, a rozsądna prezentacja jest dostępna pod adresem http://www.slideshare.net/rick446/rapid-and-scalable-development-with-mongodb-pymongo-and-ming, a także studium przypadku dotyczące migracja z SQLAlchemy do Ming http://www.slideshare.net/__amol__/from-sqlalchemy-to-ming-with-turbogears2 . Oto przykład warstwy ORM w Ming (z samouczka):

class WikiPage(MappedClass):

    class __mongometa__:
        session = session
        name = 'wiki_page'

    _id = FieldProperty(schema.ObjectId)
    title = FieldProperty(str)
    text = FieldProperty(str)
    comments=RelationProperty('WikiComment')

Zapytania używają standardowej składni zapytań MongoDB (nie magicznych argumentów słów kluczowych Django ORM):

WikiComment.query.find(dict(page_id=wp._id))