Changeset 360

Timestamp:

07/11/08 15:58:29 (5 years ago)

Author:

ged

Message:

• cleanup "copy properties from base class" implementation (closes #15)
  
• rewrite from_dict to use property names instead of column names (fixes #47,
  test from Jason R. Coombs)
  

Location:

elixir/trunk

Files:

• elixir/entity.py (modified) (11 diffs)
• tests/test_dict.py (modified) (1 diff)

elixir/trunk/elixir/entity.py

@@ -15 +15 @@
                            ForeignKeyConstraint
 from sqlalchemy.orm import Query, MapperExtension, mapper, object_session, \
-                           EXT_CONTINUE, polymorphic_union, ScopedSession
+                           EXT_CONTINUE, polymorphic_union, ScopedSession, \
+                           ColumnProperty
 
 import elixir
@@ -62 +63 @@
         self.constraints = list()
 
-        # properties waiting for a mapper to exist
+        # properties (it is only useful for checking dupe properties at the
+        # moment, and when adding properties before the mapper is created,
+        # which shouldn't happen).
         self.properties = dict()
 
@@ -326 +329 @@
     def setup_mapper(self):
         '''
-        Initializes and assign an (empty!) mapper to the entity.
+        Initializes and assign a mapper to the entity.
+        At this point the mapper will usually have no property as they are
+        added later.
         '''
         if self.entity.mapper:
@@ -400 +405 @@
 
         # do the mapping
-        kwargs['properties'] = self.properties
         if self.session is None:
             self.entity.mapper = mapper(self.entity, *args, **kwargs)
@@ -491 +495 @@
 
     def get_column(self, key, check_missing=True):
-        "need to support both the case where the table is already setup or not"
+        #TODO: this needs to work whether the table is already setup or not
         #TODO: support SA table/autoloaded entity
         for col in self.columns:
@@ -536 +540 @@
             return None
 
+    #------------------------
+    # some useful properties
+
     def table_fullname(self):
         '''
@@ -576 +583 @@
     primary_keys = property(primary_keys)
 
+    def primary_key_properties(self):
+        """
+        Returns the list of (mapper) properties corresponding to the primary
+        key columns of the table of the entity.
+
+        This property caches its value, so it shouldn't be called before the
+        entity is fully set up.
+        """
+        if not hasattr(self, '_pk_props'):
+            col_to_prop = {}
+            mapper = self.entity.mapper
+            for prop in mapper.iterate_properties:
+                if isinstance(prop, ColumnProperty):
+                    for col in prop.columns:
+                        for col in col.proxy_set:
+                            col_to_prop[col] = prop
+            pk_cols = [c for c in mapper.mapped_table.c if c.primary_key]
+            self._pk_props = [col_to_prop[c] for c in pk_cols]
+        return self._pk_props
+    primary_key_properties = property(primary_key_properties)
 
 class TriggerProxy(object):
@@ -644 +671 @@
         desc = cls._descriptor = EntityDescriptor(cls)
 
-        # Process attributes (using the assignment syntax), looking for
-        # 'Property' instances and attaching them to this entity.
-        properties = [(name, attr) for name, attr in dict_.iteritems()
-                                   if isinstance(attr, Property)]
-        sorted_props = sorted(properties, key=lambda i: i[1]._counter)
-        for name, prop in sorted_props:
-            prop.attach(cls, name)
-
+        # Determine whether this entity is a *direct* subclass of its base
+        # entity
         entity_base = None
-        for base in bases:
+        for base in cls.__bases__:
             if isinstance(base, EntityMeta):
                 if not is_entity(base):
                     entity_base = base
+
         if entity_base:
-            # Process attributes (using the assignment syntax), looking for
-            # 'Property' instances and attaching them to this entity.
+            # If so, copy the base entity properties ('Property' instances).
+            # We use inspect.getmembers (instead of __dict__) so that we also
+            # get the properties from the parents of the base_class if any.
             base_props = inspect.getmembers(entity_base,
                                             lambda a: isinstance(a, Property))
-            local_props = [(name, copy(attr)) for name, attr in base_props]
-            sorted_props = sorted(local_props, key=lambda i: i[1]._counter)
-            for name, prop in sorted_props:
-                prop.attach(cls, name)
+            base_props = [(name, copy(attr)) for name, attr in base_props]
+        else:
+            base_props = []
+
+        # Process attributes (using the assignment syntax), looking for
+        # 'Property' instances and attaching them to this entity.
+        properties = [(name, attr) for name, attr in cls.__dict__.iteritems()
+                                   if isinstance(attr, Property)]
+        sorted_props = sorted(base_props + properties,
+                              key=lambda i: i[1]._counter)
+        for name, prop in sorted_props:
+            prop.attach(cls, name)
 
         # Process mutators. Needed before _install_autosetup_triggers so that
@@ -730 +761 @@
 
     #TODO: we might want to add all columns that will be available as
-    #attributes on the class itself (in SA 0.4). This would be a pretty
+    #attributes on the class itself (in SA 0.4+). This is a pretty
     #rare usecase, as people will normally hit the query attribute before the
-    #column attributes, but still...
+    #column attributes, but I've seen people hitting this problem...
     for name in ('c', 'table', 'mapper', 'query'):
         setattr(cls, name, TriggerAttribute(name))
@@ -842 +873 @@
 
     def __init__(self, **kwargs):
-        for key, value in kwargs.items():
-            setattr(self, key, value)
+        self.from_dict(kwargs)
 
     def set(self, **kwargs):
         self.from_dict(kwargs)
+
+    def update_or_create(cls, data, surrogate=True):
+        pk_props = cls._descriptor.primary_key_properties
+
+        # if all pk are present and not None
+        if not [1 for p in pk_props if data.get(p.key) is None]:
+            pk_tuple = tuple([data[prop.key] for prop in pk_props])
+            record = cls.query.get(pk_tuple)
+            if record is None:
+                if surrogate:
+                    raise Exception("cannot create surrogate with pk")
+                else:
+                    record = cls()
+        else:
+            if surrogate:
+                record = cls()
+            else:
+                raise Exception("cannot create non surrogate without pk")
+        record.from_dict(data)
+        return record
+    update_or_create = classmethod(update_or_create)
 
     def from_dict(self, data):
@@ -853 +904 @@
         structure.
         """
+        # surrogate can be guessed from autoincrement/sequence but I guess
+        # that's not 100% reliable, so we'll need an override
+
         mapper = sqlalchemy.orm.object_mapper(self)
-        session = sqlalchemy.orm.object_session(self)
-
-        for col in mapper.mapped_table.c:
-            if not col.primary_key and data.has_key(col.name):
-                setattr(self, col.name, data[col.name])
-
-        for rel in mapper.iterate_properties:
-            rname = rel.key
-            if isinstance(rel, sqlalchemy.orm.properties.PropertyLoader) \
-                    and data.has_key(rname):
-                dbdata = getattr(self, rname)
-                if rel.uselist:
-                    pkey = [c for c in rel.table.columns if c.primary_key]
-
-                    # Build a lookup dict: {(pk1, pk2): value}
-                    lookup = dict([
-                        (tuple([getattr(o, c.name) for c in pkey]), o)
-                        for o in dbdata])
-                    for row in data[rname]:
-                        # If any primary key columns are missing or None,
-                        # create a new object
-                        if [1 for c in pkey if not row.get(c.name)]:
-                            subobj = rel.mapper.class_()
-                            dbdata.append(subobj)
-                        else:
-                            key = tuple([row[c.name] for c in pkey])
-                            subobj = lookup.pop(key, None)
-
-                            # If the row isn't found, we must fail the request
-                            # in a web scenario, this could be a parameter
-                            # tampering attack
-                            if not subobj:
-                                raise sqlalchemy.exceptions.ArgumentError(
-                                        '%s row not found in database: %s' \
-                                        % (rname, repr(row)))
-                        subobj.from_dict(row)
-
-                    # Make sure the object list attribute doesn't contain any
-                    # old value (which are not present in the new data).
-                    for delobj in lookup.itervalues():
-                        dbdata.remove(delobj)
-                        session.delete(delobj)
+
+        for key, value in data.iteritems():
+            if isinstance(value, dict):
+                dbvalue = getattr(self, key)
+                rel_class = mapper.get_property(key).mapper.class_
+                pk_props = rel_class._descriptor.primary_key_properties
+
+                # If the data doesn't contain any pk, and the relationship
+                # already has a value, update that record.
+                if not [1 for p in pk_props if p.key in data] and \
+                   dbvalue is not None:
+                    dbvalue.from_dict(value)
                 else:
-                    if data[rname] is None:
-                        setattr(self, rname, None)
-                    else:
-                        if not dbdata:
-                            dbdata = rel.mapper.class_()
-                            setattr(self, rname, dbdata)
-                        dbdata.from_dict(data[rname])
+                    record = rel_class.update_or_create(value)
+                    setattr(self, key, record)
+            elif isinstance(value, list) and \
+                 value and isinstance(value[0], dict):
+
+                rel_class = mapper.get_property(key).mapper.class_
+                new_attr_value = []
+                for row in value:
+                    if not isinstance(row, dict):
+                        raise Exception(
+                                'Cannot send mixed (dict/non dict) data '
+                                'to list relationships in from_dict data.')
+                    record = rel_class.update_or_create(row)
+                    new_attr_value.append(record)
+                setattr(self, key, new_attr_value)
+            else:
+                setattr(self, key, value)
 
     def to_dict(self, deep={}, exclude=[]):
         """Generate a JSON-style nested dict/list structure from an object."""
-        columns = []
-        for table in self.mapper.tables:
-            for col in table.c:
-                columns.append(col)
-
-        data = dict([(col.name, getattr(self, col.name))
-                     for col in columns if col.name not in exclude])
+        col_prop_names = [p.key for p in self.mapper.iterate_properties \
+                                      if isinstance(p, ColumnProperty)]
+        data = dict([(name, getattr(self, name))
+                     for name in col_prop_names if name not in exclude])
         for rname, rdeep in deep.iteritems():
             dbdata = getattr(self, rname)
+            #FIXME: use attribute names (ie coltoprop) instead of column names
             fks = self.mapper.get_property(rname).remote_side
             exclude = [c.name for c in fks]

elixir/trunk/tests/test_dict.py

@@ -3 +3 @@
 """
 
-import sqlalchemy as sa, elixir as el
+import sqlalchemy as sa
+from elixir import *
 
 def setup():
-    el.metadata.bind = 'sqlite:///'
+    metadata.bind = 'sqlite:///'
+
     global Table1, Table2, Table3
-    class Table1(el.Entity):
-        name = el.Field(el.String(30))
-        tbl2s = el.OneToMany('Table2')
-        tbl3 = el.OneToOne('Table3')
-    class Table2(el.Entity):
-        name = el.Field(el.String(30))
-        tbl1 = el.ManyToOne(Table1)
-    class Table3(el.Entity):
-        name = el.Field(el.String(30))
-        tbl1 = el.ManyToOne(Table1)
-    el.setup_all()
-    el.create_all()
+    class Table1(Entity):
+        t1id = Field(Integer, primary_key=True)
+        name = Field(String(30))
+        tbl2s = OneToMany('Table2')
+        tbl3 = OneToOne('Table3')
 
-def test_set_attr():
-    t1 = Table1()
-    t1.from_dict(dict(name='test1'))
-    assert t1.name == 'test1'
+    class Table2(Entity):
+        t2id = Field(Integer, primary_key=True)
+        name = Field(String(30))
+        tbl1 = ManyToOne(Table1)
 
-def test_nonset_attr():
-    t1 = Table1(name='test2')
-    t1.from_dict({})
-    assert t1.name == 'test2'
+    class Table3(Entity):
+        t3id = Field(Integer, primary_key=True)
+        name = Field(String(30))
+        tbl1 = ManyToOne(Table1)
 
-def test_set_rel():
-    t1 = Table1()
-    t1.from_dict(dict(tbl3={'name':'bob'}))
-    assert t1.tbl3.name == 'bob'
+    setup_all(True)
 
-def test_remove_rel():
-    t1 = Table1()
-    t1.tbl3 = Table3()
-    t1.from_dict(dict(tbl3=None))
-    assert t1.tbl3 is None
+def teardown():
+    cleanup_all(True)
 
-def test_update_rel():
-    t1 = Table1()
-    t1.tbl3 = Table3(name='fred')
-    t1.from_dict(dict(tbl3={'name':'bob'}))
-    assert t1.tbl3.name == 'bob'
+class TestDeepSet(object):
+    def test_set_attr(self):
+        t1 = Table1()
+        t1.from_dict(dict(name='test1'))
+        assert t1.name == 'test1'
 
-def test_extend_list():
-    t1 = Table1()
-    t1.from_dict(dict(tbl2s=[{'name':'test3'}]))
-    assert len(t1.tbl2s) == 1
-    assert t1.tbl2s[0].name == 'test3'
+    def test_nonset_attr(self):
+        t1 = Table1(name='test2')
+        t1.from_dict({})
+        assert t1.name == 'test2'
 
-def test_truncate_list():
-    t1 = Table1()
-    t2 = Table2()
-    t1.tbl2s.append(t2)
-    el.session.commit()
-    t1.from_dict(dict(tbl2s=[]))
-    assert len(t1.tbl2s) == 0
+    def test_set_rel(self):
+        t1 = Table1()
+        t1.from_dict(dict(tbl3={'name': 'bob'}))
+        assert t1.tbl3.name == 'bob'
 
-def test_update_list_item():
-    t1 = Table1()
-    t2 = Table2()
-    t1.tbl2s.append(t2)
-    el.session.commit()
-    t1.from_dict(dict(tbl2s=[{'id':t2.id, 'name':'test4'}]))
-    assert len(t1.tbl2s) == 1
-    assert t1.tbl2s[0].name == 'test4'
+    def test_remove_rel(self):
+        t1 = Table1()
+        t1.tbl3 = Table3()
+        t1.from_dict(dict(tbl3=None))
+        assert t1.tbl3 is None
 
-def test_invalid_update():
-    t1 = Table1()
-    t2 = Table2()
-    t1.tbl2s.append(t2)
-    el.session.commit()
-    try:
-        t1.from_dict(dict(tbl2s=[{'id':t2.id+1}]))
-        assert False
-    except sa.exceptions.ArgumentError:
-        pass
+    def test_update_rel(self):
+        t1 = Table1()
+        t1.tbl3 = Table3(name='fred')
+        t1.from_dict(dict(tbl3={'name': 'bob'}))
+        assert t1.tbl3.name == 'bob'
 
-def test_to():
-    t1 = Table1(id=50, name='test1')
-    assert t1.to_dict() == {'id':50, 'name':'test1'}
+    def test_extend_list(self):
+        t1 = Table1()
+        t1.from_dict(dict(tbl2s=[{'name': 'test3'}]))
+        assert len(t1.tbl2s) == 1
+        assert t1.tbl2s[0].name == 'test3'
 
-def test_to_deep():
-    t1 = Table1(id=51, name='test2')
-    assert t1.to_dict(deep={'tbl2s':{}}) == \
-            {'id':51, 'name':'test2', 'tbl2s':[]}
+    def test_truncate_list(self):
+        t1 = Table1()
+        t2 = Table2()
+        t1.tbl2s.append(t2)
+        session.commit()
+        t1.from_dict(dict(tbl2s=[]))
+        assert len(t1.tbl2s) == 0
 
-def test_to_deep2():
-    t1 = Table1(id=52, name='test3')
-    t2 = Table2(id=50, name='test4')
-    t1.tbl2s.append(t2)
-    el.session.commit()
-    assert t1.to_dict(deep={'tbl2s':{}}) == \
-            {'id':52, 'name':'test3', 'tbl2s':[{'id':50, 'name':'test4'}]}
+    def test_update_list_item(self):
+        t1 = Table1()
+        t2 = Table2()
+        t1.tbl2s.append(t2)
+        session.commit()
+        t1.from_dict(dict(tbl2s=[{'t2id': t2.t2id, 'name': 'test4'}]))
+        assert len(t1.tbl2s) == 1
+        assert t1.tbl2s[0].name == 'test4'
 
-def test_to_deep3():
-    t1 = Table1(id=53, name='test2')
-    t1.tbl3 = Table3(id=50, name='wobble')
-    el.session.commit()
-    assert t1.to_dict(deep={'tbl3':{}}) == \
-            {'id':53, 'name':'test2', 'tbl3':{'id':50,'name':'wobble'}}
+    def test_invalid_update(self):
+        t1 = Table1()
+        t2 = Table2()
+        t1.tbl2s.append(t2)
+        session.commit()
+        try:
+            t1.from_dict(dict(tbl2s=[{'t2id':t2.t2id+1}]))
+            assert False
+        except:
+            pass
+
+    def test_to(self):
+        t1 = Table1(t1id=50, name='test1')
+        assert t1.to_dict() == {'t1id': 50, 'name': 'test1'}
+
+    def test_to_deep(self):
+        t1 = Table1(t1id=51, name='test2')
+        assert t1.to_dict(deep={'tbl2s':{}}) == \
+                {'t1id': 51, 'name': 'test2', 'tbl2s': []}
+
+    def test_to_deep2(self):
+        t1 = Table1(t1id=52, name='test3')
+        t2 = Table2(t2id=50, name='test4')
+        t1.tbl2s.append(t2)
+        session.commit()
+        assert t1.to_dict(deep={'tbl2s':{}}) == \
+                {'t1id': 52,
+                 'name': 'test3',
+                 'tbl2s': [{'t2id': 50, 'name': 'test4'}]}
+
+    def test_to_deep3(self):
+        t1 = Table1(t1id=53, name='test2')
+        t1.tbl3 = Table3(t3id=50, name='wobble')
+        session.commit()
+        assert t1.to_dict(deep={'tbl3':{}}) == \
+                {'t1id': 53,
+                 'name': 'test2',
+                 'tbl3': {'t3id': 50, 'name': 'wobble'}}
+
+class TestSetOnAliasedColumn(object):
+    def setup(self):
+        metadata.bind = 'sqlite:///'
+
+    def teardown(self):
+        cleanup_all(True)
+
+    def test_set_on_aliased_column(self):
+        class A(Entity):
+            name = Field(String(60), colname='strName')
+
+        setup_all(True)
+
+        a = A()
+        a.set(name='Aye')
+
+        assert a.name == 'Aye'
+        session.flush()
+        session.clear()
+