jon-example

from sqlalchemy import MetaData, create_engine
from sqlalchemy.orm import scoped_session, sessionmaker


class BrainStorage(object):
    
    def __init__(self, conn_str):
        self.conn_str = conn_str
        self.engine   = create_engine(conn_str)
        self.meta     = MetaData(bind=engine)
        self.session  = scoped_session(sessionmaker(bind=self.engine))
    
    def init_model(self):

        self.node_table = sqlalchemy.Table('node', meta.metadata,
          sqlalchemy.Column('id', sqlalchemy.Integer, primary_key=True),
          sqlalchemy.Column('type', sqlalchemy.String, nullable=False),
          sqlalchemy.Column('name', sqlalchemy.String),
          sqlalchemy.Column('parent_id', sqlalchemy.ForeignKey('node.id')),
        )
        
        class Node(object):
            mp = sqlamp.MPManager(self.node_table, self.node_table.c.id, self.node_table.c.parent_id)
            def __init__(self, name, value=None, parent=None):
                self.name = name
                self.value = value
                self.parent = parent

            def __repr__(self):
                return "<Node %r>" % self.name

            def __getitem__(self, name):
                try:
                    return self.children[name] # allow node[0] for the first node
                except TypeError:
                    return [child for child in self.children if child.name == name][0]

            def __setitem__(self, name, value):
                assert isinstance(value, Node)
                if isinstance(name, basestring):
                    value.name = name
                    self.children.append(value)
                else:
                    self.children[name] = value

                node_mapper = sqlalchemy.orm.mapper(
            Node, self.node_table,
            extension=[Node.mp.mapper_extension],
            polymorphic_on=node_table.c.type,
            polymorphic_identity='node',
            properties=dict(
                parent=sqlalchemy.orm.relation(Node,
                                               remote_side=[node_table.c.id],
                                               backref=sqlalchemy.orm.backref('children', cascade='all, delete'),
                                               cascade='all, delete')
            )
        )

        self.Node = Node
        return Node